package api

import (
	"strconv"
	"web/models"
	"web/pkg/app"
	"web/pkg/e"
	"web/pkg/util"
	"web/service/order"

	"github.com/gin-gonic/gin"
)

// OrderListRequest 订单列表请求参数结构体
type OrderListRequest struct {
	OrderSn   string `json:"order_sn" form:"order_no"`     // 订单号，支持JSON和URL参数
	Status    int    `json:"status" form:"status"`         // 订单状态
	UID       uint64 `json:"uid" form:"uid"`               // 用户ID
	PayStatus int    `json:"pay_status" form:"pay_status"` // 支付状态
}

type OrderController struct {
}

// NewOrderController 创建订单控制器实例
func NewOrderController() *OrderController {
	return &OrderController{}
}

// List 获取订单列表
func (oc *OrderController) List(c *gin.Context) {
	// 解析分页参数
	pageInfo := util.ParsePageInfo(c)

	// 使用Gin框架推荐的结构体绑定方式解析请求参数
	var req OrderListRequest
	if err := c.ShouldBind(&req); err != nil {
		app.Fail(c, e.INVALID_PARAMS, "参数格式错误")
		return
	}

	// 构建筛选参数
	filters := make(map[string]interface{})
	if req.OrderSn != "" {
		filters["order_no"] = req.OrderSn
	}
	if req.Status > 0 {
		filters["status"] = req.Status
	}
	if req.UID > 0 {
		filters["uid"] = req.UID
	}
	if req.PayStatus > 0 {
		filters["pay_status"] = req.PayStatus
	}

	// 获取订单列表
	orders, nextPageInfo, err := order.NewOrderService().Gets(filters, pageInfo)
	if err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	// 填充关联数据
	fillOptions := util.FillOption{
		"order_items":    true,
		"order_evaluate": true,
	}
	order.NewFillOrderService().Fill(orders, fillOptions)

	// 编码响应
	encodedOrders := order.NewEncodeOrderService().EncodeList(orders)
	resp := util.MakePagedResponse(encodedOrders, nextPageInfo)
	app.Success(c, resp)
}

// Show 获取订单详情
func (oc *OrderController) Show(c *gin.Context) {
	// 获取订单ID
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		app.Fail(c, e.INVALID_PARAMS, "订单ID格式错误")
		return
	}

	// 获取订单详情
	orderData, err := order.NewOrderService().Get(uint(id))
	if err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	// 填充关联数据
	fillOptions := util.FillOption{
		"order_items":    true,
		"order_evaluate": true,
	}
	order.NewFillOrderService().FillOne(orderData, fillOptions)

	// 编码响应
	resp := order.NewEncodeOrderService().Encode(orderData)
	app.Success(c, resp)
}

// Store 创建订单
func (oc *OrderController) Store(c *gin.Context) {
	var orderData models.LaOrder
	if err := c.ShouldBindJSON(&orderData); err != nil {
		app.Fail(c, e.INVALID_PARAMS, err.Error())
		return
	}

	// 创建订单
	if err := order.NewOrderService().Create(&orderData); err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	// 编码响应
	resp := order.NewEncodeOrderService().Encode(&orderData)
	app.Success(c, resp)
}

// Update 更新订单
func (oc *OrderController) Update(c *gin.Context) {
	// 获取订单ID
	idStr := c.Param("id")
	_, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		app.Fail(c, e.INVALID_PARAMS, "订单ID格式错误")
		return
	}

	// 检查订单是否存在
	exists, err := order.NewOrderService().ExistByOrderNo("")
	if err != nil || !exists {
		app.Fail(c, e.ERROR, "订单不存在")
		return
	}

	var orderData models.LaOrder
	if err := c.ShouldBindJSON(&orderData); err != nil {
		app.Fail(c, e.INVALID_PARAMS, err.Error())
		return
	}

	id, _ := strconv.ParseUint(idStr, 10, 32)
	orderData.ID = int(id)

	// 更新订单
	if err := order.NewOrderService().Update(&orderData); err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	// 编码响应
	resp := order.NewEncodeOrderService().Encode(&orderData)
	app.Success(c, resp)
}

// Delete 删除订单
func (oc *OrderController) Delete(c *gin.Context) {
	// 获取订单ID
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		app.Fail(c, e.INVALID_PARAMS, "订单ID格式错误")
		return
	}

	// 删除订单
	if err := order.NewOrderService().Delete(uint(id)); err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	app.Success(c, nil)
}

// GetByUid 根据用户ID获取订单列表
func (oc *OrderController) GetByUid(c *gin.Context) {
	// 获取用户ID
	uidStr := c.Param("uid")
	uid, err := strconv.ParseUint(uidStr, 10, 64)
	if err != nil {
		app.Fail(c, e.INVALID_PARAMS, "用户ID格式错误")
		return
	}

	// 解析分页参数
	pageInfo := util.ParsePageInfo(c)

	// 获取用户订单列表
	orders, nextPageInfo, err := order.NewOrderService().GetByUid(uid, pageInfo)
	if err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}
	// 填充关联数据
	fillOptions := util.FillOption{
		"order_items":    true,
		"order_evaluate": true,
	}
	order.NewFillOrderService().Fill(orders, fillOptions)

	// 编码响应
	encodedOrders := order.NewEncodeOrderService().EncodeList(orders)
	resp := util.MakePagedResponse(encodedOrders, nextPageInfo)
	app.Success(c, resp)
}

// GetByStatus 根据状态获取订单列表
func (oc *OrderController) GetByStatus(c *gin.Context) {
	// 获取状态
	statusStr := c.Param("status")
	status, err := strconv.Atoi(statusStr)
	if err != nil {
		app.Fail(c, e.INVALID_PARAMS, "状态格式错误")
		return
	}

	// 解析分页参数
	pageInfo := util.ParsePageInfo(c)

	// 获取状态订单列表
	orders, nextPageInfo, err := order.NewOrderService().GetByStatus(status, pageInfo)
	if err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	// 填充关联数据
	fillOptions := util.FillOption{
		"order_items":    true,
		"order_evaluate": true,
	}
	order.NewFillOrderService().Fill(orders, fillOptions)

	// 编码响应
	encodedOrders := order.NewEncodeOrderService().EncodeList(orders)
	resp := util.MakePagedResponse(encodedOrders, nextPageInfo)
	app.Success(c, resp)
}

// GetOrderByOrderNo 根据订单号获取订单详情
func (oc *OrderController) GetOrderByOrderNo(c *gin.Context) {
	// 获取订单号
	orderNo := c.Param("order_no")
	if orderNo == "" {
		app.Fail(c, e.INVALID_PARAMS, "订单号不能为空")
		return
	}

	// 获取订单详情
	orderData, err := order.NewOrderService().GetByOrderNo(orderNo)
	if err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	// 填充关联数据
	fillOptions := util.FillOption{
		"order_items":    true,
		"order_evaluate": true,
	}
	order.NewFillOrderService().FillOne(orderData, fillOptions)

	// 编码响应
	resp := order.NewEncodeOrderService().Encode(orderData)
	app.Success(c, resp)
}

// GetUserOrders 获取用户订单列表
func (oc *OrderController) GetUserOrders(c *gin.Context) {
	// 获取用户ID
	uidStr := c.Param("uid")
	uid, err := strconv.ParseUint(uidStr, 10, 64)
	if err != nil {
		app.Fail(c, e.INVALID_PARAMS, "用户ID格式错误")
		return
	}

	// 解析分页参数
	pageInfo := util.ParsePageInfo(c)

	// 获取用户订单列表
	orders, nextPageInfo, err := order.NewOrderService().GetByUid(uid, pageInfo)
	if err != nil {
		app.Fail(c, e.ERROR, err.Error())
		return
	}

	// 填充关联数据
	fillOptions := util.FillOption{
		"order_items":    true,
		"order_evaluate": true,
	}
	order.NewFillOrderService().Fill(orders, fillOptions)

	// 编码响应
	encodedOrders := order.NewEncodeOrderService().EncodeList(orders)
	resp := util.MakePagedResponse(encodedOrders, nextPageInfo)
	app.Success(c, resp)
}
